home *** CD-ROM | disk | FTP | other *** search
/ Workbench Design / WB Collection.iso / datatypes / dfadt / source / dfadt_libinit.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-04-07  |  5.3 KB  |  256 lines
  1. /* $Revision Header built automatically *************** (do not edit) ************
  2. **
  3. ** © Copyright by Dirk Federlein
  4. **
  5. ** File             : Work:programming/dfa/Sourcen_V2.3/Datatypes/dfadt_libinit.c
  6. ** Created on       : Dienstag, 14.03.95 15:08:08
  7. ** Created by       : Dirk Federlein
  8. ** Current revision : V1.0
  9. **
  10. **
  11. ** Purpose
  12. ** -------
  13. **     Inits the datatype class
  14. **
  15. ** Revision V1.0
  16. ** --------------
  17. ** created on Dienstag, 14.03.95 15:08:08  by  Dirk Federlein.   LogMessage :
  18. **     --- Initial release ---
  19. **
  20. *********************************************************************************/
  21.  
  22. #include "all_includes.h"
  23. #include "dfadt.h"
  24.  
  25. #include "dfa.datatype_rev.h"
  26.  
  27. char                    version[]        = VERSTAG;
  28.  
  29. struct Library * __asm __saveds    LibInit(register __a0 BPTR Segment, register __d0 struct Library *Base);
  30. struct Library * __asm __saveds    LibOpen(register __a6 struct Library *Base);
  31. BPTR __asm __saveds                LibExpunge(register __a6 struct Library *Base);
  32. BPTR __asm __saveds                LibClose(register __a6 struct Library *Base);
  33. LONG __asm __saveds                LibNull(register __a6 struct Library *Base);
  34.  
  35. Class * __saveds                GetClassEngine(VOID);
  36.  
  37. BPTR                            LibSegment    = NULL;
  38. UBYTE __aligned                    LibName[]    = "dfa.datatype";
  39. UBYTE __aligned                    LibID[]        = VSTRING;
  40.  
  41.  
  42. struct ExecBase            * SysBase;
  43. struct DosLibrary        * DOSBase;
  44. struct IntuitionBase    * IntuitionBase;
  45. struct GfxBase            * GfxBase;
  46. struct Library            * LayersBase,
  47.                         * UtilityBase,
  48.                         * DataTypesBase,
  49.                         * SuperClassBase;
  50.  
  51. Class                    * TextClass;
  52.  
  53. struct SignalSemaphore    LockSemaphore;
  54.  
  55.  
  56. APTR LibVectors[] =  /* die Sprungtabelle */
  57. {
  58.     LibOpen,
  59.     LibClose,
  60.     LibExpunge,
  61.     LibNull,
  62.     GetClassEngine,
  63.     (APTR)-1
  64. };
  65.  
  66. struct 
  67. { 
  68.     ULONG DataSize; 
  69.     APTR Table; 
  70.     APTR Data; 
  71.     struct Library * (*Init)(); 
  72. } __aligned LibInitTab =
  73.     {
  74.         sizeof(struct Library),
  75.         LibVectors,
  76.         NULL,
  77.         LibInit
  78.     };
  79.  
  80. struct Library * __asm __saveds
  81. LibInit(register __a0 BPTR Segment,register __d0 struct Library *Base)
  82. {
  83.  
  84.     Base -> lib_Node . ln_Type  = NT_LIBRARY;
  85.     Base -> lib_Node . ln_Name  = LibName;
  86.     Base -> lib_Flags           = LIBF_CHANGED | LIBF_SUMUSED;
  87.     Base -> lib_Version         = VERSION;
  88.     Base -> lib_Revision        = REVISION;
  89.     Base -> lib_IdString        = LibID;
  90.  
  91.     LibSegment = Segment;
  92.     SysBase = *(struct ExecBase **)4;
  93.     InitSemaphore(&LockSemaphore);
  94.  
  95.  
  96.     return(Base);
  97. }
  98.  
  99.  
  100. struct Library * __asm __saveds
  101. LibOpen(register __a6 struct Library *Base)
  102. {
  103.     Base -> lib_OpenCnt++;
  104.     Base -> lib_Flags &= ~LIBF_DELEXP;
  105.  
  106.  
  107.     if(Base -> lib_OpenCnt == 1)
  108.     {
  109.         ObtainSemaphore(&LockSemaphore);
  110.  
  111.         if(DOSBase = (struct DosLibrary *)OpenLibrary("dos.library",37))
  112.         {
  113.             if(IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library",37))
  114.             {
  115.                 if(GfxBase = (struct GfxBase *)OpenLibrary("graphics.library",39))
  116.                 {
  117.                     if(UtilityBase = OpenLibrary("utility.library",0))
  118.                     {
  119.                         if(LayersBase = OpenLibrary("layers.library",0))
  120.                         {
  121.                             if(DataTypesBase = OpenLibrary("datatypes.library",0))
  122.                             {
  123.                                 if(SuperClassBase = OpenLibrary("datatypes/text.datatype",0))
  124.                                 {
  125.                                     if(TextClass = MakeClass("dfa.datatype", TEXTDTCLASS,NULL,sizeof(struct DDTData),NULL))
  126.                                     {
  127.                                         extern ULONG ClassDispatch();
  128.  
  129.  
  130.                                         TextClass->cl_Dispatcher.h_Entry = (HOOKFUNC)ClassDispatch;
  131.                                         TextClass->cl_UserData = (ULONG) Base;
  132.                                         AddClass(TextClass);
  133.                                         ReleaseSemaphore(&LockSemaphore);
  134.                                         return(Base);
  135.                                     }
  136.  
  137.                                     CloseLibrary(SuperClassBase);
  138.                                     SuperClassBase = NULL;
  139.                                 }
  140.                                 CloseLibrary(DataTypesBase);
  141.                                 DataTypesBase = NULL;
  142.                             }
  143.                             CloseLibrary(LayersBase);
  144.                             LayersBase = NULL;
  145.                         }
  146.                         CloseLibrary(UtilityBase);
  147.                         UtilityBase = NULL;
  148.                     }
  149.                     CloseLibrary(GfxBase);
  150.                     GfxBase = NULL;
  151.                 }
  152.                 CloseLibrary(IntuitionBase);
  153.                 IntuitionBase = NULL;
  154.             }
  155.             CloseLibrary(DOSBase);
  156.             DOSBase = NULL;
  157.         }
  158.  
  159.         ReleaseSemaphore(&LockSemaphore);
  160.         return(NULL);
  161.  
  162.     }
  163.     else
  164.         return(Base);
  165. }
  166.  
  167. BPTR __asm __saveds LibExpunge(register __a6 struct Library *Base)
  168. {
  169.     BPTR TempSegment = LibSegment;
  170.  
  171.  
  172.     if(!Base -> lib_OpenCnt && TempSegment)
  173.     {
  174.         Remove((struct Node *)Base);
  175.         FreeMem((BYTE *)Base - Base -> lib_NegSize, Base -> lib_NegSize + Base -> lib_PosSize);
  176.         LibSegment = NULL;
  177.         return(TempSegment);
  178.     }
  179.     else
  180.     {
  181.         Base -> lib_Flags |= ~LIBF_DELEXP;
  182.         return(NULL);
  183.     }
  184. }
  185.  
  186. BPTR __asm __saveds LibClose(register __a6 struct Library *Base)
  187. {
  188.  
  189.     if(!(Base -> lib_OpenCnt--))
  190.         Base -> lib_OpenCnt = 0;
  191.  
  192.  
  193.     if(!Base -> lib_OpenCnt)
  194.     {
  195.         ObtainSemaphore(&LockSemaphore);
  196.  
  197.         if(TextClass)
  198.         {
  199.             RemoveClass(TextClass);
  200.             FreeClass(TextClass);
  201.             TextClass = NULL;
  202.         }
  203.  
  204.         CloseLibrary(SuperClassBase);
  205.         SuperClassBase = NULL;
  206.  
  207.         CloseLibrary(DataTypesBase);
  208.         DataTypesBase = NULL;
  209.  
  210.         CloseLibrary(LayersBase);
  211.         LayersBase = NULL;
  212.  
  213.         CloseLibrary(UtilityBase);
  214.         UtilityBase = NULL;
  215.  
  216.         CloseLibrary(IntuitionBase);
  217.         IntuitionBase = NULL;
  218.  
  219.         CloseLibrary(GfxBase);
  220.         GfxBase = NULL;
  221.  
  222.         CloseLibrary(DOSBase);
  223.         DOSBase = NULL;
  224.  
  225.         ReleaseSemaphore(&LockSemaphore);
  226.     }
  227.  
  228.     if((Base -> lib_Flags & LIBF_DELEXP) && !Base -> lib_OpenCnt)
  229.         return(LibExpunge(Base));
  230.  
  231.     return(NULL);
  232. }
  233.  
  234. LONG __asm __saveds
  235. LibNull(register __a6 struct Library *Base)
  236. {
  237.  
  238.     return(NULL);
  239. }
  240.  
  241. Class * __saveds GetClassEngine()
  242. {
  243.     Class *class;
  244.  
  245.     ObtainSemaphore(&LockSemaphore);
  246.  
  247.     class = TextClass;
  248.  
  249.     ReleaseSemaphore(&LockSemaphore);
  250.  
  251.     return(class);
  252.  
  253.  
  254. }
  255.  
  256.